const User = require('../models/User');
const jwt = require('jsonwebtoken');
const friendService = require('../services/friendService');

// 生成JWT令牌
const generateToken = (id) => {
  const secret = process.env.JWT_SECRET || 'litechat-default-secret-key';
  return jwt.sign({ id }, secret, {
    expiresIn: '30d',
  });
};

// @desc    注册新用户
// @route   POST /api/users
// @access  Public
const registerUser = async (req, res) => {
  try {
    console.log('📝 收到用户注册请求:', req.body);
    console.log('🔑 JWT_SECRET 状态:', process.env.JWT_SECRET ? '已设置' : '❌ 未设置');
    
    const { username, email, password } = req.body;

    // 检查用户是否已存在
    console.log('🔍 检查用户是否已存在:', { username, email });
    const userExists = await User.findOne({ $or: [{ email }, { username }] });

    if (userExists) {
      console.log('⚠️ 用户已存在:', userExists.email);
      return res.status(400).json({ message: '用户已存在' });
    }

    // 创建用户
    console.log('🔨 开始创建新用户...');
    const user = await User.create({
      username,
      email,
      password,
    });

    console.log('✅ 用户创建成功:', {
      id: user._id,
      username: user.username,
      email: user.email
    });

    if (user) {
      const token = generateToken(user._id);
      console.log('🎫 生成token成功');
      
      res.status(201).json({
        _id: user._id,
        username: user.username,
        email: user.email,
        avatar: user.avatar,
        status: user.status,
        token: token,
      });
      
      console.log('📤 注册响应已发送');
    } else {
      console.log('❌ 用户创建失败 - 返回数据为空');
      res.status(400).json({ message: '无效的用户数据' });
    }
  } catch (error) {
    console.error('❌ 用户注册失败:', error);
    res.status(500).json({ message: '服务器错误' });
  }
};

// @desc    登录用户
// @route   POST /api/users/login
// @access  Public
const loginUser = async (req, res) => {
  try {
    const { email, password } = req.body;

    // 检查用户
    const user = await User.findOne({ email });

    if (user && (await user.matchPassword(password))) {
      // 更新状态为在线
      user.status = 'online';
      await user.save();
      
      res.json({
        _id: user._id,
        username: user.username,
        email: user.email,
        avatar: user.avatar,
        status: user.status,
        token: generateToken(user._id),
      });
    } else {
      res.status(401).json({ message: '邮箱或密码错误' });
    }
  } catch (error) {
    console.error(error);
    res.status(500).json({ message: '服务器错误' });
  }
};

// @desc    获取用户个人资料
// @route   GET /api/users/profile
// @access  Private
const getUserProfile = async (req, res) => {
  try {
    const user = await User.findById(req.user._id);

    if (user) {
      res.json({
        _id: user._id,
        username: user.username,
        email: user.email,
        avatar: user.avatar,
        status: user.status,
        bio: user.bio,
        location: user.location,
        birthday: user.birthday,
        createdAt: user.createdAt,
        updatedAt: user.updatedAt
      });
    } else {
      res.status(404).json({ message: '用户不存在' });
    }
  } catch (error) {
    console.error(error);
    res.status(500).json({ message: '服务器错误' });
  }
};

// @desc    更新用户个人资料
// @route   PUT /api/users/profile
// @access  Private
const updateUserProfile = async (req, res) => {
  try {
    console.log('收到更新个人资料请求:', req.body);
    
    const user = await User.findById(req.user._id);

    if (!user) {
      return res.status(404).json({ message: '用户不存在' });
    }

    // 允许更新的字段
    const { username, email, bio, location, birthday, avatar } = req.body;

    if (username) {
      // 检查用户名是否已被其他用户使用
      const usernameExists = await User.findOne({ username, _id: { $ne: req.user._id } });
      if (usernameExists) {
        return res.status(400).json({ message: '该用户名已被使用' });
      }
      user.username = username;
    }

    if (email) {
      // 检查邮箱是否已被其他用户使用
      const emailExists = await User.findOne({ email, _id: { $ne: req.user._id } });
      if (emailExists) {
        return res.status(400).json({ message: '该邮箱已被使用' });
      }
      user.email = email;
    }

    // 更新其他字段
    if (bio !== undefined) user.bio = bio;
    if (location !== undefined) user.location = location;
    if (birthday !== undefined) user.birthday = birthday;
    
    // 处理头像更新
    if (avatar !== undefined) {
      console.log('更新头像:', avatar);
      
      // 直接设置头像值，无论是URL还是emoji格式
      user.avatar = avatar;
      console.log('头像已更新为:', user.avatar);
    }

    await user.save();
    console.log('用户资料保存成功');

    res.json({
      _id: user._id,
      username: user.username,
      email: user.email,
      avatar: user.avatar,
      bio: user.bio,
      location: user.location,
      birthday: user.birthday,
      status: user.status
    });
  } catch (error) {
    console.error('更新个人资料错误:', error);
    res.status(500).json({ message: '服务器错误' });
  }
};

// @desc    获取用户公开资料
// @route   GET /api/users/:userId
// @access  Private
const getUserById = async (req, res) => {
  try {
    const user = await User.findById(req.params.userId).select('-password');

    if (!user) {
      return res.status(404).json({ message: '用户不存在' });
    }

    // 检查是否为好友
    const isFriend = await friendService.checkFriendship(req.user._id.toString(), req.params.userId);

    res.json({
      ...user.toJSON(),
      isFriend
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ message: '服务器错误' });
  }
};

// @desc    搜索用户
// @route   GET /api/users/search
// @access  Private
const searchUsers = async (req, res) => {
  try {
    const keyword = req.query.keyword
      ? {
          $or: [
            { username: { $regex: req.query.keyword, $options: 'i' } },
            { email: { $regex: req.query.keyword, $options: 'i' } },
          ],
        }
      : {};

    // 不包括当前用户并限制结果数量
    const users = await User.find({
      ...keyword,
      _id: { $ne: req.user._id },
    })
      .select('-password')
      .limit(10);

    res.json(users);
  } catch (error) {
    console.error(error);
    res.status(500).json({ message: '服务器错误' });
  }
};

// @desc    发送好友请求
// @route   POST /api/users/friend-requests
// @access  Private
const sendFriendRequest = async (req, res) => {
  try {
    const { userId } = req.body;

    // 检查用户是否存在
    const receiver = await User.findById(userId);
    if (!receiver) {
      return res.status(404).json({ message: '用户不存在' });
    }

    // 使用MySQL服务发送好友请求
    const result = await friendService.sendFriendRequest(
      req.user._id.toString(), 
      userId
    );

    res.status(201).json(result);
  } catch (error) {
    console.error('发送好友请求错误:', error);
    res.status(error.message === '已经是好友了' || error.message === '已经有一个待处理的好友请求' 
      ? 400 
      : 500
    ).json({ message: error.message || '服务器错误' });
  }
};

// @desc    响应好友请求
// @route   PUT /api/users/friend-requests/:requestId
// @access  Private
const respondToFriendRequest = async (req, res) => {
  try {
    const { requestId } = req.params;
    const { action } = req.body;

    if (!['accepted', 'rejected'].includes(action)) {
      return res.status(400).json({ message: '无效的操作' });
    }

    // 使用MySQL服务响应好友请求
    const result = await friendService.respondToFriendRequest(
      requestId,
      req.user._id.toString(),
      action
    );

    res.json(result);
  } catch (error) {
    console.error('响应好友请求错误:', error);
    res.status(error.message.includes('不存在') ? 404 : 500)
      .json({ message: error.message || '服务器错误' });
  }
};

// @desc    获取好友列表
// @route   GET /api/users/friends
// @access  Private
const getFriends = async (req, res) => {
  try {
    // 使用MySQL服务获取好友列表
    const friends = await friendService.getUserFriends(req.user._id.toString());
    res.json(friends);
  } catch (error) {
    console.error('获取好友列表错误:', error);
    res.status(500).json({ message: '服务器错误' });
  }
};

// @desc    获取好友请求列表
// @route   GET /api/users/friend-requests
// @access  Private
const getFriendRequests = async (req, res) => {
  try {
    // 使用MySQL服务获取好友请求
    const requests = await friendService.getFriendRequests(req.user._id.toString());
    res.json(requests);
  } catch (error) {
    console.error('获取好友请求错误:', error);
    res.status(500).json({ message: '服务器错误' });
  }
};

// @desc    上传用户头像
// @route   POST /api/users/avatar
// @access  Private
const uploadAvatar = async (req, res) => {
  try {
    console.log('收到头像上传请求:', req.file);
    
    if (!req.file) {
      return res.status(400).json({ message: '请上传头像文件' });
    }

    const user = await User.findById(req.user._id);
    if (!user) {
      return res.status(404).json({ message: '用户不存在' });
    }

    // 构建头像URL
    const avatarUrl = `/uploads/avatars/${req.file.filename}`;
    console.log('头像URL:', avatarUrl);
    
    // 更新用户头像
    user.avatar = avatarUrl;
    await user.save();
    console.log('用户头像已更新到MongoDB');

    res.json({
      message: '头像上传成功',
      avatar: avatarUrl
    });
  } catch (error) {
    console.error('头像上传错误:', error);
    res.status(500).json({ message: '服务器错误' });
  }
};

module.exports = {
  registerUser,
  loginUser,
  getUserProfile,
  updateUserProfile,
  getUserById,
  searchUsers,
  sendFriendRequest,
  respondToFriendRequest,
  getFriends,
  getFriendRequests,
  uploadAvatar,
}; 